

"""
    1，假定有下面的列表: names = ['fentiao','fendai','fensi','apple']
    输出结果为:'I have fentiao, fendai, fensi and apple.'
    2，已知一个数字列表，求所有元素和。
    3，将列表逆序输出，使用三种方式。
"""

# 1，假定有下面的列表: names = ['fentiao','fendai','fensi','apple']
#     输出结果为:'I have fentiao, fendai, fensi and apple.'

def display_list(listTmp):
    print('I have ', end='')
    list_len = len(listTmp);
    for index,value in enumerate(listTmp):
        print(f'{value}', end='')
        if index < list_len - 2:
            print(f' , ', end='')
        elif index < list_len - 1:
            print(f' and ', end='')
    print()
def display_list2(listTmp):
    print(f'I have '+ ' , '.join(names[:3]) + ' and '+names[3])

def display_list3(listTmp):
    print(f"names[-1]= {names[-1]}")  #负数表表示从最后一个元素开始，-1是最后一个元素
    #names[:-1] 表示从0开始切片，-1是最后一个元素，不包括
    #[:-1]切片操作指定了开始索引（默认为0，即列表的开头）和结束索引（-1，即列表的最后一个元素之前的位置）。由于切片操作是左闭右开的，所以结束索引处的元素不会被包含在切片结果中。
    print(f"I have {' , '.join(names[:-1])} and {names[-1]}.")  #


def display_list4(listTmp):
    tmp = 'I have '+','.join(names)
    print('tmp=',tmp)
    #从右往左找字符串出现的位置
    print(tmp.rfind(","))
    print(tmp[:tmp.rfind(",")] + ' and '+tmp[tmp.rfind(",")+1:])


names = ['fentiao','fendai','fensi','apple']
display_list(names)
display_list2(names)
display_list3(names)
display_list4(names)
#



#2，已知一个数字列表，求所有元素和。
def num_sum(num_tmp):
    total = 0
    for value in num_tmp:
        total += value
    return total


num_list = [1 ,2 ,3 ,4 ,5]
total =  num_sum(num_list)
print(f'num={total}')


def num_sum2(num_tmp):
    total = 0
    for index in range( 0 , len(num_tmp)):
        total += num_tmp[index]
    return total
total =  num_sum2(num_list)
print(f'num={total}')


# 没有sum这个函数
def num_sum3(num_tmp):
    return sum(num_tmp)

#sum =  num_sum3(num_list)
# print(f'sum3={sum([1,2,3])}')


#3，将列表逆序输出，使用三种方式。

# 第一种方法：str_list.reverse()
def reverse_1 (str_list):
    str_list.reverse()
    print('reverse_1.list.reverse=' , str_list)

#
def reverse_2 (str_list):
    tmp_list = str_list[::-1]
    print('reverse_2.list[::-1]=' , tmp_list)

def reverse_3 (str_list):
    index = len(str_list)-1
    tmp_list = []
    for value in str_list:
        tmp_list.append(str_list[index])
        index -= 1
    print('reverse_3.for list=', tmp_list)


def reverse_4 (str_list):
    tmp_list = str_list[::-1]
    #tmp_list = str_list[len(str_list)::-1] #start=指定开始位置,end 默认整个长度
    # str_list = ['a', 'b', 'c', 'd', 'e']
    #tmp_list = str_list[2:1:-1] #start=指定开始位置,end=结束位置（正向索引位置）
    print('reverse_4.list[::-1]=' , tmp_list)

def reverse_str (str_tmp):
    #python
    print('reverse_str.str[::1]=', str_tmp[0:2:1]) #start=0，从0开始切片索引， end=2，结束的索引（不包含2）,step步长=1(左到右)， python = py
    print('reverse_str.str[::-1]=', str_tmp[::-1]) #start默认从序列开始的索引 ， end默认到序列结束,step=-1(步长负数右到左)，即逆序 python = nohtyp
    print('reverse_str.str[5:4:-1]=', str_tmp[5:4:-1])#start=5，从序列开始的索引， end=4序列结束索引（不包含4）,step=-1(步长负数右到左)，即 python = n
    print('reverse_str.str[5:3:-1]=', str_tmp[5:3:-1])#start=5，从序列开始的索引， end=3序列结束索引（不包含3）,step=-1(步长负数右到左)，即 python = no
    print('reverse_str.str[5:2:-1]=', str_tmp[5:2:-1])#start=5，从序列开始的索引， end=2序列结束索引（不包含3）,step=-1(步长负数右到左)，即 python = noh
    print('reverse_str.str[5:1:-1]=', str_tmp[5:1:-1])#start=5，从序列开始的索引， end=1序列结束索引（不包含3）,step=-1(步长负数右到左)，即 python = noht
    print('reverse_str.str[5:0:-1]=', str_tmp[5:0:-1]) #start=5，从序列开始的索引， end=0序列结束索引（不包含0）,step=-1(步长负数右到左)，即逆序少一个字符（end=0不不含0） python = nohty


def reverse_5 (str_list):
    #排序 首先需要保证列表是有序的才行，否则不行
    str_list.sort(reverse=True)
    print('reverse_5.str_list.sort=' , str_list)

def reverse_6 (str_list):
    tmp_list = []
    for i in range(len(str_list) - 1 , -1 , -1):  #右到左， 从最后一个元素开始， 步长每次减1, 一直到0结束（不包括-1）
        tmp_list.append(str_list[i])
    print('reverse_6.tmp_list=', tmp_list)
    #推导式
    print('reverse_6.for推导式' , [str_list[i] for i in range(len(str_list)-1 , -1 , -1)])


def reverse_7 (str_list):
    tmp_list = []
    # i=0 ,[-1-i]= -1-0 = -1 倒数第一个元素，最后一个元素
    # i=1 ,[-1-i]= -1-1 = -2 倒数第二个元素
    # i=2 ,[-1-i]= -1-2 = -3 倒数第三个元素
    # i=3 ,[-1-i]= -1-3 = -4 倒数第四个元素
    for i in range(len(str_list)):
        tmp_list.append(str_list[-1-i])
    print('reverse_7.tmp_list=', tmp_list)


def reverse_8 (str_list):
    tmp_list = []
    for i in str_list:
        tmp_list.insert(0,i)  #从列表最左开始，永远插入第0个元素，从左到右遍历到最后，就完成逆序了
    print('reverse_8.tmp_list=', tmp_list)

def reverse_9 (str_list):
    tmp_list = list(reversed(str_list)) # 使用列表逆序函数reversed()
    print('reverse_9.tmp_list=', tmp_list)

def reverse_10 (str_list):
    tmp_list = list(str_list)
    #使用算法
    #如：列表数组=[1,2,  3  ,4,5] , 将第一位、第二位元素 与 倒数第一位、倒数第二位的元素交互即可
    # 即 1 与 5元素交换，  2 与 4 元素交换
    for i in range(len(tmp_list) // 2):  #  //取整数（列表遍历数组长度一半 取整数）
        tmp_list[i] , tmp_list[-1-i] = tmp_list[-1-i],tmp_list[i]
    print('reverse_10.tmp_list=', tmp_list)


def reverse_11 (str_list):
    tmp_list = list(str_list)
    final_list = []
    for i in range(0 , len(tmp_list)):
        final_list.append(tmp_list.pop())#删除最后一个元素，删除的时候返回值就是被当前删除的元素，将删除的元素放入一个列表就完成逆序了
    print('reverse_11.final_list=', final_list)



str_list = ['a' ,'b' ,'c' ,'d' ,'e']
reverse_1(str_list)
str_list = ['a' ,'b' ,'c' ,'d' ,'e']
reverse_2(str_list)
str_list = ['a' ,'b' ,'c' ,'d' ,'e']
str_list2 = ['c' ,'a' ,'b' ,'d' ,'e']
reverse_3(str_list)
reverse_5(str_list2)
reverse_6(str_list)
reverse_7(str_list)
reverse_8(str_list)
reverse_9(str_list)
reverse_10(str_list)
reverse_11(str_list)


numbers = [1,2,3,4,5]
total = sum(numbers)
print(type(numbers))
print('total.sum()函数={}' , total) #
s = sum(i for i in num_list if isinstance(i , int))
print(f"total.sum列表推导式={s}")

#错误 TypeError: 'int' object is not callable 通常发生在Python中，
# 当你尝试调用一个整数（int）对象，就像它是一个函数一样。这通常是因为你意外地覆盖了一个函数名或者变量名与一个整数。
# sum = 10
# numbers = [1, 2, 3, 4, 5]
# total = sum(numbers)  # 这里会抛出 TypeError，因为 sum 现在是一个整数，不是一个函数




reverse_str('python')

